जावास्क्रिप्टची प्रोटोटाइप चेन उघड करणे: वारसा नमुने आणि ऑब्जेक्ट निर्मिती

जावास्क्रिप्ट, त्याच्या गाभ्याशी, एक गतिमान आणि बहुमुखी भाषा आहे जी दशकांपासून वेबला सामर्थ्य देत आहे. ECMAScript 6 (ES6) आणि त्यापुढील काळात सादर केलेल्या तिच्या कार्यात्मक पैलूंशी आणि आधुनिक सिंटॅक्सशी अनेक डेव्हलपर्स परिचित असले तरी, भाषेवर खऱ्या अर्थाने प्रभुत्व मिळवण्यासाठी तिच्या मूलभूत यंत्रणा समजून घेणे महत्त्वाचे आहे. सर्वात मूलभूत परंतु अनेकदा गैरसमज असलेल्या संकल्पनांपैकी एक म्हणजे प्रोटोटाइप चेन. ही पोस्ट प्रोटोटाइप चेनबद्दलचे गूढ उकलून सांगेल, ती ऑब्जेक्ट निर्मिती कशी सुलभ करते आणि विविध वारसा नमुने कसे सक्षम करते हे शोधून काढेल, जगभरातील डेव्हलपर्ससाठी जागतिक दृष्टिकोन प्रदान करेल.

पाया: जावास्क्रिप्टमधील ऑब्जेक्ट्स आणि प्रॉपर्टीज

प्रोटोटाइप चेनमध्ये खोलवर जाण्यापूर्वी, जावास्क्रिप्टमध्ये ऑब्जेक्ट्स कसे कार्य करतात याची मूलभूत माहिती घेऊया. जावास्क्रिप्टमध्ये, जवळजवळ प्रत्येक गोष्ट एक ऑब्जेक्ट असते. ऑब्जेक्ट्स हे की-व्हॅल्यू जोड्यांचे संकलन आहेत, जिथे की (keys) हे प्रॉपर्टीची नावे (सामान्यतः स्ट्रिंग किंवा सिम्बॉल्स) असतात आणि व्हॅल्यूज (values) कोणत्याही डेटा प्रकाराच्या असू शकतात, ज्यात इतर ऑब्जेक्ट्स, फंक्शन्स किंवा प्रिमिटिव्ह व्हॅल्यूज यांचा समावेश आहे.

एक साधा ऑब्जेक्ट विचारात घ्या:

            const person = {
  name: "Alice",
  age: 30,
  greet: function() {
    console.log(`Hello, my name is ${this.name}.`);
  }
};

console.log(person.name); // Output: Alice
person.greet();        // Output: Hello, my name is Alice.

            

              
                Copy
              
            
          

जेव्हा तुम्ही person.name सारख्या ऑब्जेक्टच्या प्रॉपर्टीला ॲक्सेस करता, तेव्हा जावास्क्रिप्ट प्रथम ती प्रॉपर्टी थेट ऑब्जेक्टवरच शोधते. जर ती सापडली नाही, तर ते तिथेच थांबत नाही. इथेच प्रोटोटाइप चेनची भूमिका येते.

प्रोटोटाइप म्हणजे काय?

प्रत्येक जावास्क्रिप्ट ऑब्जेक्टला एक अंतर्गत प्रॉपर्टी असते, जिला अनेकदा [[Prototype]] असे संबोधले जाते, जी दुसऱ्या ऑब्जेक्टकडे निर्देश करते. या दुसऱ्या ऑब्जेक्टला मूळ ऑब्जेक्टचा प्रोटोटाइप म्हणतात. जेव्हा तुम्ही एखाद्या ऑब्जेक्टवरील प्रॉपर्टीला ॲक्सेस करण्याचा प्रयत्न करता आणि ती प्रॉपर्टी थेट ऑब्जेक्टवर सापडत नाही, तेव्हा जावास्क्रिप्ट ती ऑब्जेक्टच्या प्रोटोटाइपवर शोधते. जर ती तिथेही सापडली नाही, तर ती प्रोटोटाइपच्या प्रोटोटाइपकडे पाहते, आणि असेच पुढे एक साखळी तयार होते.

ही साखळी तोपर्यंत चालू राहते जोपर्यंत जावास्क्रिप्टला प्रॉपर्टी सापडत नाही किंवा साखळीच्या शेवटपर्यंत पोहोचत नाही, जो सामान्यतः Object.prototype असतो, ज्याचा [[Prototype]] null असतो. या यंत्रणेला प्रोटोटाइपल वारसा असे म्हणतात.

प्रोटोटाइपला ॲक्सेस करणे

[[Prototype]] हे एक अंतर्गत स्लॉट असले तरी, ऑब्जेक्टच्या प्रोटोटाइपशी संवाद साधण्याचे दोन मुख्य मार्ग आहेत:

• Object.getPrototypeOf(obj): ऑब्जेक्टचा प्रोटोटाइप मिळवण्यासाठी हा मानक आणि शिफारस केलेला मार्ग आहे.
• obj.__proto__: ही एक अप्रचलित पण व्यापकपणे समर्थित नसलेली प्रॉपर्टी आहे जी प्रोटोटाइप देखील परत करते. उत्तम सुसंगतता आणि मानकांचे पालन करण्यासाठी Object.getPrototypeOf() वापरण्याचा सल्ला दिला जातो.

const person = {
  name: "Alice"
};

const personPrototype = Object.getPrototypeOf(person);
console.log(personPrototype === Object.prototype); // Output: true

// Using the deprecated __proto__
console.log(person.__proto__ === Object.prototype); // Output: true

प्रोटोटाइप चेन कार्यपद्धतीत

प्रोटोटाइप चेन हे मूलतः ऑब्जेक्ट्सची एक लिंक केलेली यादी (linked list) आहे. जेव्हा तुम्ही एखाद्या प्रॉपर्टीला ॲक्सेस करण्याचा प्रयत्न करता (मिळवणे, सेट करणे किंवा हटवणे), तेव्हा जावास्क्रिप्ट या चेनमधून जाते:

1. जावास्क्रिप्ट प्रॉपर्टी थेट ऑब्जेक्टवर अस्तित्वात आहे का हे तपासते.
2. जर सापडली नाही, तर ती ऑब्जेक्टच्या प्रोटोटाइपवर (obj.[[Prototype]]) तपासते.
3. तरीही सापडली नाही, तर ती प्रोटोटाइपच्या प्रोटोटाइपवर तपासते, आणि असेच पुढे.
4. जोपर्यंत प्रॉपर्टी सापडत नाही किंवा ज्या ऑब्जेक्टचा प्रोटोटाइप null आहे (सामान्यतः Object.prototype) अशा ऑब्जेक्टवर साखळी संपत नाही तोपर्यंत हे चालू राहते.

एका उदाहरणाने स्पष्ट करूया. कल्पना करा की आपल्याकडे एक बेस `Animal` कन्स्ट्रक्टर फंक्शन आहे आणि नंतर एक `Dog` कन्स्ट्रक्टर फंक्शन आहे जे `Animal` मधून वारसा घेते.

// Constructor function for Animal
function Animal(name) {
  this.name = name;
}

Animal.prototype.speak = function() {
  console.log(`${this.name} makes a sound.`);
};

// Constructor function for Dog
function Dog(name, breed) {
  Animal.call(this, name); // Call the parent constructor
  this.breed = breed;
}

// Setting up the prototype chain: Dog.prototype inherits from Animal.prototype
Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog; // Correct the constructor property

Dog.prototype.bark = function() {
  console.log(`Woof! My name is ${this.name} and I'm a ${this.breed}.`);
};

const myDog = new Dog("Buddy", "Golden Retriever");

console.log(myDog.name);     // Output: Buddy (found on myDog)
myDog.speak();    // Output: Buddy makes a sound. (found on Dog.prototype via Animal.prototype)
myDog.bark();     // Output: Woof! My name is Buddy and I'm a Golden Retriever. (found on Dog.prototype)

console.log(Object.getPrototypeOf(myDog) === Dog.prototype); // Output: true
console.log(Object.getPrototypeOf(Dog.prototype) === Animal.prototype); // Output: true
console.log(Object.getPrototypeOf(Animal.prototype) === Object.prototype); // Output: true
console.log(Object.getPrototypeOf(Object.prototype) === null); // Output: true

या उदाहरणामध्ये:

• myDog मध्ये थेट name आणि breed प्रॉपर्टी आहे.
• जेव्हा myDog.speak() ला कॉल केला जातो, तेव्हा जावास्क्रिप्ट myDog वर speak शोधते. ते सापडत नाही.
• तेव्हा ते Object.getPrototypeOf(myDog) कडे पाहते, जे Dog.prototype आहे. तिथे speak सापडत नाही.
• तेव्हा ते Object.getPrototypeOf(Dog.prototype) कडे पाहते, जे Animal.prototype आहे. इथे, speak सापडते! फंक्शन कार्यान्वित होते, आणि speak मधील this हे myDog चा संदर्भ देते.

ऑब्जेक्ट निर्मितीचे नमुने

प्रोटोटाइप चेन जावास्क्रिप्टमध्ये ऑब्जेक्ट्स कसे तयार केले जातात याच्याशी आंतरिकरित्या जोडलेली आहे. ऐतिहासिकदृष्ट्या, ES6 क्लासेसपूर्वी, ऑब्जेक्ट निर्मिती आणि वारसा प्राप्त करण्यासाठी अनेक नमुने (patterns) वापरले जात होते:

1. कन्स्ट्रक्टर फंक्शन्स

वरील Animal आणि Dog उदाहरणांमध्ये पाहिल्याप्रमाणे, कन्स्ट्रक्टर फंक्शन्स ऑब्जेक्ट्स तयार करण्याचा एक पारंपरिक मार्ग आहे. जेव्हा तुम्ही एखाद्या फंक्शनसोबत new कीवर्ड वापरता, तेव्हा जावास्क्रिप्ट अनेक क्रिया करते:

1. एक नवीन रिकामा ऑब्जेक्ट तयार केला जातो.
2. हा नवीन ऑब्जेक्ट कन्स्ट्रक्टर फंक्शनच्या prototype प्रॉपर्टीशी जोडला जातो (म्हणजेच, newObj.[[Prototype]] = Constructor.prototype).
3. कन्स्ट्रक्टर फंक्शन this शी जोडलेल्या नवीन ऑब्जेक्टसह बोलावले जाते.
4. जर कन्स्ट्रक्टर फंक्शनने स्पष्टपणे ऑब्जेक्ट परत केले नाही, तर नव्याने तयार केलेला ऑब्जेक्ट (this) आपोआप परत केला जातो.

कन्स्ट्रक्टरच्या प्रोटोटाइपवर परिभाषित केलेल्या सामायिक पद्धतींसह ऑब्जेक्ट्सची अनेक इन्स्टन्सेस तयार करण्यासाठी हा नमुना शक्तिशाली आहे.

2. फॅक्टरी फंक्शन्स

फॅक्टरी फंक्शन्स म्हणजे केवळ ऑब्जेक्ट परत करणारी फंक्शन्स. ते new कीवर्ड वापरत नाहीत आणि कन्स्ट्रक्टर फंक्शन्सप्रमाणे प्रोटोटाइपशी आपोआप जोडले जात नाहीत. तथापि, ते परत केलेल्या ऑब्जेक्टचा प्रोटोटाइप स्पष्टपणे सेट करून प्रोटोटाइपचा फायदा घेऊ शकतात.

function createPerson(name, age) {
  const person = Object.create(personFactory.prototype);
  person.name = name;
  person.age = age;
  return person;
}

personFactory.prototype.greet = function() {
  console.log(`Hello, I'm ${this.name}`);
};

const john = createPerson("John", 25);
john.greet(); // Output: Hello, I'm John

इथे Object.create() ही एक महत्त्वाची पद्धत आहे. ती एक नवीन ऑब्जेक्ट तयार करते, ज्यामध्ये विद्यमान ऑब्जेक्टला नव्याने तयार केलेल्या ऑब्जेक्टचा प्रोटोटाइप म्हणून वापरले जाते. यामुळे प्रोटोटाइप चेनवर स्पष्ट नियंत्रण ठेवता येते.

3. `Object.create()`

वर सूचित केल्याप्रमाणे, Object.create(proto, [propertiesObject]) हे निर्दिष्ट प्रोटोटाइपसह ऑब्जेक्ट्स तयार करण्यासाठी एक मूलभूत साधन आहे. हे तुम्हाला कन्स्ट्रक्टर फंक्शन्स पूर्णपणे बायपास करून थेट ऑब्जेक्टचा प्रोटोटाइप सेट करण्याची अनुमती देते.

const personPrototype = {
  greet: function() {
    console.log(`Hello, my name is ${this.name}`);
  }
};

// Create a new object 'bob' with 'personPrototype' as its prototype
const bob = Object.create(personPrototype);
bob.name = "Bob";
bob.greet(); // Output: Hello, my name is Bob

// You can even pass properties as a second argument
const charles = Object.create(personPrototype, {
  name: { value: "Charles", writable: true, enumerable: true, configurable: true }
});
charles.greet(); // Output: Hello, my name is Charles

पूर्वनिर्धारित प्रोटोटाइपसह ऑब्जेक्ट्स तयार करण्यासाठी, लवचिक वारसा संरचना सक्षम करण्यासाठी ही पद्धत अत्यंत शक्तिशाली आहे.

ES6 क्लासेस: सिंटॅक्टिक शुगर

ES6 च्या आगमनाने, जावास्क्रिप्टने class सिंटॅक्स सादर केला. जावास्क्रिप्टमधील क्लासेस हे प्रामुख्याने विद्यमान प्रोटोटाइपल वारसा यंत्रणेवरील सिंटॅक्टिक शुगर आहेत हे समजून घेणे महत्त्वाचे आहे. ते क्लास-आधारित ऑब्जेक्ट-ओरिएंटेड भाषांमधून येणाऱ्या डेव्हलपर्ससाठी एक स्वच्छ, अधिक परिचित सिंटॅक्स प्रदान करतात.

// Using ES6 class syntax
class AnimalES6 {
  constructor(name) {
    this.name = name;
  }

  speak() {
    console.log(`${this.name} makes a sound.`);
  }
}

class DogES6 extends AnimalES6 {
  constructor(name, breed) {
    super(name); // Calls the parent class constructor
    this.breed = breed;
  }

  bark() {
    console.log(`Woof! My name is ${this.name} and I'm a ${this.breed}.`);
  }
}

const myDogES6 = new DogES6("Rex", "German Shepherd");
myDogES6.speak(); // Output: Rex makes a sound.
myDogES6.bark();  // Output: Woof! My name is Rex and I'm a German Shepherd.

// Under the hood, this still uses prototypes:
console.log(Object.getPrototypeOf(myDogES6) === DogES6.prototype); // Output: true
console.log(Object.getPrototypeOf(DogES6.prototype) === AnimalES6.prototype); // Output: true

जेव्हा तुम्ही एक क्लास परिभाषित करता, तेव्हा जावास्क्रिप्ट मूलतः एक कन्स्ट्रक्टर फंक्शन तयार करते आणि प्रोटोटाइप चेन आपोआप सेट करते:

• constructor पद्धत ऑब्जेक्ट इन्स्टन्सच्या प्रॉपर्टीज परिभाषित करते.
• क्लास बॉडीमध्ये परिभाषित केलेल्या पद्धती (जसे की speak आणि bark) त्या क्लासशी संबंधित कन्स्ट्रक्टर फंक्शनच्या prototype प्रॉपर्टीवर आपोआप ठेवल्या जातात.
• extends कीवर्ड वारसा संबंध सेट करतो, ज्यामुळे चाइल्ड क्लासचा प्रोटोटाइप पॅरेंट क्लासच्या प्रोटोटाइपशी जोडला जातो.

प्रोटोटाइप चेन जागतिक स्तरावर का महत्त्वाची आहे

प्रोटोटाइप चेन समजून घेणे हा केवळ एक शैक्षणिक अभ्यास नाही; विशेषतः जागतिक संदर्भात, मजबूत, कार्यक्षम आणि देखभाल करण्यायोग्य जावास्क्रिप्ट ॲप्लिकेशन्स विकसित करण्यासाठी त्याचे गंभीर परिणाम आहेत:

• कार्यक्षमतेचे ऑप्टिमायझेशन (Performance Optimization): प्रत्येक स्वतंत्र ऑब्जेक्ट इन्स्टन्सवर पद्धती परिभाषित करण्याऐवजी प्रोटोटाइपवर पद्धती परिभाषित करून, तुम्ही मेमरी वाचवता. सर्व इन्स्टन्सेस समान पद्धत फंक्शन्स सामायिक करतात, ज्यामुळे अधिक कार्यक्षम मेमरी वापर होतो, जे जगभरातील विविध उपकरणांवर आणि नेटवर्क परिस्थितीवर तैनात केलेल्या ॲप्लिकेशन्ससाठी महत्त्वाचे आहे.
• कोड पुनर्वापर (Code Reusability): प्रोटोटाइप चेन ही कोड पुनर्वापरासाठी जावास्क्रिप्टची प्राथमिक यंत्रणा आहे. वारसा तुम्हाला कोडची नक्कल न करता कार्यक्षमता वाढवून जटिल ऑब्जेक्ट श्रेणीबद्धता तयार करण्यास अनुमती देतो. आंतरराष्ट्रीय प्रकल्पांवर काम करणाऱ्या मोठ्या, वितरित संघांसाठी हे अमूल्य आहे.
• सखोल डिबगिंग (Deep Debugging): जेव्हा त्रुटी येतात, तेव्हा प्रोटोटाइप चेन ट्रेस केल्याने अनपेक्षित वर्तनाच्या स्त्रोताचा शोध घेण्यात मदत होते. वारसा, स्कोप आणि `this` बंधन संबंधित समस्यांचे डिबगिंग करण्यासाठी प्रॉपर्टीज कशा शोधल्या जातात हे समजून घेणे महत्त्वाचे आहे.
• फ्रेमवर्क्स आणि लायब्ररीज (Frameworks and Libraries): अनेक लोकप्रिय जावास्क्रिप्ट फ्रेमवर्क्स आणि लायब्ररीज (उदा. React, Angular, Vue.js च्या जुन्या आवृत्त्या) प्रोटोटाइप चेनवर मोठ्या प्रमाणात अवलंबून असतात किंवा तिच्याशी संवाद साधतात. प्रोटोटाइपचे ठोस ज्ञान तुम्हाला त्यांची अंतर्गत कार्यपद्धती समजून घेण्यास आणि त्यांचा अधिक प्रभावीपणे वापर करण्यास मदत करते.
• भाषा आंतरक्रियाशीलता (Language Interoperability): प्रोटोटाइपसह जावास्क्रिप्टची लवचिकता इतर प्रणाली किंवा भाषांसह एकीकरण करणे सोपे करते, विशेषतः Node.js सारख्या वातावरणात जिथे जावास्क्रिप्ट नेटिव्ह मॉड्यूल्सशी संवाद साधते.
• वैचारिक स्पष्टता (Conceptual Clarity): ES6 क्लासेस काही गुंतागुंत दूर करतात, तरीही प्रोटोटाइपची मूलभूत माहिती तुम्हाला पडद्यामागे काय घडत आहे हे समजून घेण्यास अनुमती देते. हे तुमचे आकलन वाढवते आणि तुम्हाला तुमच्या भौगोलिक स्थान किंवा पसंतीच्या विकास वातावरणाची पर्वा न करता, विशेष प्रकरणे आणि प्रगत परिस्थिती अधिक आत्मविश्वासाने हाताळण्यास सक्षम करते.

सामान्य त्रुटी आणि सर्वोत्तम पद्धती

शक्तिशाली असूनही, प्रोटोटाइप चेन काळजीपूर्वक हाताळली नाही तर गोंधळ निर्माण करू शकते. येथे काही सामान्य त्रुटी आणि सर्वोत्तम पद्धती दिल्या आहेत:

त्रुटी 1: अंगभूत प्रोटोटाइपमध्ये बदल करणे

Array.prototype किंवा Object.prototype सारख्या अंगभूत ऑब्जेक्ट प्रोटोटाइपवर पद्धती जोडणे किंवा सुधारणे ही सामान्यतः चांगली कल्पना नाही. यामुळे नावांचे संघर्ष आणि अनपेक्षित वर्तन होऊ शकते, विशेषतः मोठ्या प्रकल्पांमध्ये किंवा जेव्हा थर्ड-पार्टी लायब्ररी वापरल्या जातात ज्या या प्रोटोटाइपच्या मूळ वर्तनावर अवलंबून असू शकतात.

सर्वोत्तम पद्धत: तुमची स्वतःची कन्स्ट्रक्टर फंक्शन्स, फॅक्टरी फंक्शन्स किंवा ES6 क्लासेस वापरा. जर तुम्हाला कार्यक्षमता वाढवायची असेल, तर युटिलिटी फंक्शन्स तयार करण्याचा किंवा मॉड्यूल्स वापरण्याचा विचार करा.

त्रुटी 2: चुकीची कन्स्ट्रक्टर प्रॉपर्टी

जेव्हा वारसा मॅन्युअली सेट केला जातो (उदा. Dog.prototype = Object.create(Animal.prototype)), तेव्हा नवीन प्रोटोटाइपची (Dog.prototype) constructor प्रॉपर्टी मूळ कन्स्ट्रक्टरकडे (Animal) निर्देश करेल. यामुळे `instanceof` तपासण्या आणि इंट्रोस्पेक्शनमध्ये समस्या येऊ शकतात.

सर्वोत्तम पद्धत: वारसा सेट केल्यानंतर नेहमी constructor प्रॉपर्टी स्पष्टपणे रीसेट करा:

Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;

त्रुटी 3: `this` संदर्भाचे आकलन

प्रोटोटाइप पद्धतींमध्ये this चे वर्तन महत्त्वाचे आहे. this नेहमी त्या ऑब्जेक्टचा संदर्भ देते ज्यावर पद्धत बोलावली जाते, ती पद्धत कुठे परिभाषित केली आहे याचा नाही. प्रोटोटाइप चेनमध्ये पद्धती कशा कार्य करतात यासाठी हे मूलभूत आहे.

सर्वोत्तम पद्धत: पद्धती कशा बोलावल्या जातात याची काळजी घ्या. जर तुम्हाला `this` संदर्भ स्पष्टपणे सेट करण्याची आवश्यकता असेल, विशेषतः जेव्हा पद्धती कॉलबॅक म्हणून पास केल्या जातात, तेव्हा `.call()`, `.apply()`, किंवा `.bind()` वापरा.

त्रुटी 4: इतर भाषांमधील क्लासेससोबतचा गोंधळ

क्लासिकल वारसा (जसे की Java किंवा C++ मध्ये) वापरणारे डेव्हलपर्सना जावास्क्रिप्टचे प्रोटोटाइपल वारसा मॉडेल सुरुवातीला प्रति-सहज (counter-intuitive) वाटू शकते. लक्षात ठेवा की ES6 क्लासेस एक दर्शनी भाग आहेत; अंतर्निहित यंत्रणा अजूनही प्रोटोटाइपच आहे.

सर्वोत्तम पद्धत: जावास्क्रिप्टच्या प्रोटोटाइपल स्वभावाचा स्वीकार करा. ऑब्जेक्ट्स त्यांच्या प्रोटोटाइपद्वारे प्रॉपर्टी लुकअप कसे करतात हे समजून घेण्यावर लक्ष केंद्रित करा.

मूलभूत पलीकडे: प्रगत संकल्पना

`instanceof` ऑपरेटर

instanceof ऑपरेटर तपासतो की ऑब्जेक्टच्या प्रोटोटाइप चेनमध्ये विशिष्ट कन्स्ट्रक्टरची prototype प्रॉपर्टी आहे की नाही. प्रोटोटाइपल सिस्टममध्ये प्रकार तपासणीसाठी हे एक शक्तिशाली साधन आहे.

console.log(myDog instanceof Dog);      // Output: true
console.log(myDog instanceof Animal);   // Output: true
console.log(myDog instanceof Object);   // Output: true
console.log(myDog instanceof Array);    // Output: false

`isPrototypeOf()` पद्धत

Object.prototype.isPrototypeOf() पद्धत तपासते की एखादा ऑब्जेक्ट दुसऱ्या ऑब्जेक्टच्या प्रोटोटाइप चेनमध्ये कुठेही दिसतो का.

console.log(Dog.prototype.isPrototypeOf(myDog));    // Output: true
console.log(Animal.prototype.isPrototypeOf(myDog)); // Output: true
console.log(Object.prototype.isPrototypeOf(myDog)); // Output: true

प्रॉपर्टीजचे शेडोइंग (Shadowing)

ऑब्जेक्टवरील प्रॉपर्टीला त्याच्या प्रोटोटाइपवरील प्रॉपर्टीला शेडो केले जाते असे म्हणतात, जर तिचे नाव समान असेल. जेव्हा तुम्ही प्रॉपर्टीला ॲक्सेस करता, तेव्हा ऑब्जेक्टवरील प्रॉपर्टी मिळवली जाते आणि प्रोटोटाइपवरील प्रॉपर्टी दुर्लक्षित केली जाते (जोपर्यंत ऑब्जेक्टची प्रॉपर्टी हटवली जात नाही). हे डेटा प्रॉपर्टीज आणि मेथड्स दोन्हीला लागू होते.

class Person {
  constructor(name) {
    this.name = name;
  }
  greet() {
    console.log(`Hello from Person: ${this.name}`);
  }
}

class Employee extends Person {
  constructor(name, id) {
    super(name);
    this.id = id;
  }

  // Shadowing the greet method from Person
  greet() {
    console.log(`Hello from Employee: ${this.name}, ID: ${this.id}`);
  }
}

const emp = new Employee("Jane", "E123");
emp.greet(); // Output: Hello from Employee: Jane, ID: E123

// To call the parent's greet method, we'd need super.greet()

निष्कर्ष

जावास्क्रिप्ट प्रोटोटाइप चेन ही एक मूलभूत संकल्पना आहे जी ऑब्जेक्ट्स कसे तयार केले जातात, प्रॉपर्टीज कशा ॲक्सेस केल्या जातात आणि वारसा कसा प्राप्त केला जातो याचा आधार आहे. ES6 क्लासेससारखे आधुनिक सिंटॅक्स त्याचा वापर सोपा करत असले तरी, प्रोटोटाइपचे सखोल ज्ञान कोणत्याही गंभीर जावास्क्रिप्ट डेव्हलपरसाठी आवश्यक आहे. या संकल्पनेवर प्रभुत्व मिळवून, तुम्हाला अधिक कार्यक्षम, पुनर्वापर करण्यायोग्य आणि देखभाल करण्यायोग्य कोड लिहिण्याची क्षमता मिळते, जी जागतिक प्रकल्पांवर प्रभावीपणे सहयोग करण्यासाठी महत्त्वपूर्ण आहे. तुम्ही बहुराष्ट्रीय कॉर्पोरेशनसाठी किंवा आंतरराष्ट्रीय वापरकर्ता आधार असलेल्या लहान स्टार्टअपसाठी डेव्हलप करत असाल तरीही, जावास्क्रिप्टच्या प्रोटोटाइपल वारशाचे ठोस ज्ञान तुमच्या विकास साधनांच्या भांडारात एक शक्तिशाली साधन म्हणून काम करेल.

शोधत राहा, शिकत राहा आणि आनंदी कोडिंग करत राहा!